The present invention relates generally to the field of computer graphics, and more particularly, to the problem of determining the set of objects/surfaces visible from a defined viewpoint in a graphics environment.
Visualization software has proven to be very useful in evaluating three-dimensional designs long before the physical realization of those designs. In addition, visualization software has shown its cost effectiveness by allowing engineering companies to find design problems early in the design cycle, thus saving them significant amounts of money. Unfortunately, the need to view more and more complex scenes has outpaced the ability of graphics hardware systems to display them at reasonable frame rates. As scene complexity grows, visualization software designers need to carefully use the rendering resource provided by graphic hardware pipelines.
A hardware pipeline wastes rendering bandwidth when it discards triangle work. Rendering bandwidth waste can be decreased by not asking the pipeline to draw triangles that it will discard. Various software methods for reducing pipeline waste have evolved over time. Each technique reduces waste at a different point within the pipeline. As examples, software frustum culling can significantly reduce discards in a pipeline""s clipping computation while software backface culling can reduce discards in a pipeline""s lighting computation.
The z-buffer is the final part of the graphics pipeline that discards work. In essence, the z-buffer retains visible surfaces and discards those not visible. As scene complexity increases, especially in walk through and CAD environments, the number of occluded surfaces rises rapidly and as a result the number of surfaces that the z-buffer discards rises as well. A frame""s average depth complexity determines roughly how much work (and thus rendering bandwidth) the z-buffer discards. In a frame with a per-pixel depth complexity of d the pipeline""s effectiveness is 1/d. As depth complexity rises, the hardware pipeline thus becomes proportionally less and less effective.
Software occlusion culling has been proposed as an additional tool for improving rendering effectiveness. A visualization program which performs occlusion culling effectively increases the graphic hardware""s overall rendering bandwidth by not asking the hardware pipeline to draw occluded objects. Computing a scene""s visible objects is the complementary problem to that of occlusion culling. Rather than removing occluded objects from the set of objects in a scene or even a frustum culled scene, a program instead computes which objects are visible and draws just those. A simple visualization program can compute the set of visible objects and draw those objects from the current viewpoint, allowing the pipeline to remove backfacing polygons and the z-buffer to remove any non-visible surfaces.
One technique for computing the visible object set uses ray casting. RealEyes [Sowizral, H. A., Zikan, K., Esposito, C., Janin, A., Mizell, D. xe2x80x9cRealEyes: A System for Visualizing Very Large Physical Structuresxe2x80x9d, SIGGRAPH ""94, Visual Proceedings, 1994, p. 228], a system that implemented the ray casting technique, was demonstrated in SIGGRAPH 1994""s BOOM room. At interactive rates, visitors could xe2x80x9cwalkxe2x80x9d around the interior of a Boeing 747 or explore the structures comprising Space Station Freedom""s lab module.
The intuition for the use of rays in determining visibility relies on the properties of light. The first object encountered along a ray is visible since it alone can reflect light into the viewer""s eye. Also, that object interposes itself between the viewer and all succeeding objects along the ray making them not visible. In the discrete world of computer graphics, it is difficult to propagate a continuum of rays. So a discrete subset of rays is invariably used. Of course, this implies that visible objects or segments of objects smaller than the resolution of the ray sample may be missed and not discovered. This is because rays guarantee correct determination of visible objects only up to the density of the ray-sample. FIG. 1 illustrates the ray-based method of visible object detection. Rays that interact with one or more objects are marked with a dot at the point of their first contact with an object. It is this point of first contact that determines the value of the screen pixel corresponding to the ray. Also observe that the object denoted A is small enough to be entirely missed by the given ray sample.
Visible-object determination has its roots in visible-surface determination. Foley et al. [Foley, J., van Dam, A., Feiner, S. and Hughes, J. Computer Graphics: Principles and Practice, 2nd ed., Addison-Wesley, Chapter 15, pp.649-718, 1996] divide visible-surface determination approaches into two broad groups: image-precision and object-precision algorithms. Image precision algorithms typically operate at the resolution of the display device and tend to have superior performance computationally. Object precision approaches operate in object space-usually performing object to object comparisons.
A prototypical image-precision visible-surface-determination algorithm casts rays from the viewpoint through the center of each display pixel to determine the nearest visible surface along each ray. The list of applications of visible-surface ray casting (or ray tracing) is long and distinguished. Appel [xe2x80x9cSome Techniques for Shading Machine Rendering of Solidsxe2x80x9d, SJCC""68, pp. 37-45, 1968] uses ray casting for shading. Goldstein and Nagel [Mathematical Applications Group, Inc., xe2x80x9c3-D Simulated Graphics Offered by Service Bureau,xe2x80x9d Datamation, 13(1), Febuaray 1968, p. 69.; see also Goldstein, R. A. and Nagel, R. xe2x80x9c3-D Visual Simulationxe2x80x9d, Simulation, 16(1), pp.25-31, 1971] use ray casting for boolean set operations. Kay et al. [Kay, D. S. and Greenberg, D., xe2x80x9cTransparency for Computer Synthesized Images,xe2x80x9d SIGGRAPH""79, pp.158-164] and Whitted [xe2x80x9cAn Improved Illumination Model for Shaded Displayxe2x80x9d, CACM, 23(6). pp.343-349, 1980] use ray tracing for refraction and specular reflection computations. Airey et al. [Airey, J. M., Rohlf, J. H. and Brooks, Jr. F. P. Towards Image Realism with Interactive Update Rates in Complex Virtual Building Environments. ACM SIGGRAPH Symposium on Interactive 3D Graphics, 24, 2(1990), pp. 41-50] uses ray casting for computing the portion of a model visible from a given cell.
Another approach to visible-surface determination relies on sending beams or cones into a database of surfaces [see Dadoun et al., xe2x80x9cHierarchical approachs to hidden surface intersection testing.xe2x80x9d Proceeedings of Graphics Interface ""82, Toronto, May 1982, 49-56; see also Dadoun et al., xe2x80x9cThe geometry of beam tracing.xe2x80x9d In Joseph O""Rourke, ed., Proceeedings of the Symposium on Computational Geometry, pp.55-61, ACM Press, New York, 1985]. Essentially, beams become a replacement for rays. The approach usually results in compact beams decomposing into a set of possibly non-connected cone(s) after interacting with an object.
A variety of spatial subdivision schemes have been used to impose a spatial structure on the objects in a scene. [The following four references pertain to spatial subdivision schemes: (a) Glassner, xe2x80x9cSpace subdivision for fast ray tracing,xe2x80x9d IEEE CGandA, 4(10):15-22, October 1984; (b) Jevans et al., xe2x80x9cAdaptive voxel subdivision for ray tracing,xe2x80x9d Proceedings Graphics Interface ""89, 164-172, June 1989; (c) Kaplan, M. xe2x80x9cThe use of spatial coherence in ray tracing,xe2x80x9d in Techniques for Computer Graphics . . . , Rogers, D. and Earnshaw, R. A. (eds), Springer-Verlag, New York, 1987; and (d) Rubin, S. M. and Whitted, T. xe2x80x9cA 3-dimensional representation for fast rendering of complex scenes,xe2x80x9d Computer Graphics, 14(3):110-116, July 1980. ]
Kay et al. [Kay, T. L. and Kajiya, J. T. xe2x80x9cRay Tracing Complex Scenesxe2x80x9d, SIGGRAPH 1986, pp. 269-278,1986], concentrating on the computational aspect of ray casting, employed a hierarchy of spatial bounding volumes in conjunction with rays, to determine the visible objects along each ray. Of course, the spatial hierarchy needs to be precomputed. However, once in place, such a hierarchy facilitates a recursive computation for finding objects. If the environment is stationary, the same data-structure facilitates finding the visible object along any ray from any origin.
Teller et al. [Teller, S. and Sequin, C. H. xe2x80x9cVisibility Preprocessing for Interactive Walkthroughs,xe2x80x9d SIGGRAPH ""91, pp.61-69] use preprocessing to full advantage in visible-object computation by precomputing cell-to-cell visibility. Their approach is essentially an object precision approach and they report over 6 hours of preprocessing time to calculate 58 Mbytes of visibility information for a 250,000 polygon model on a 50 MIP machine [Teller, S. and Sequin. C. H. xe2x80x9cVisibility computations in polyhedral three-dimensional environments,xe2x80x9d U.C. Berkeley Report No. UCB/CSD 92/680, April 1992 ].
In a different approach to visibility computation, Greene et al. [Greene, N., Kass, M., and Miller, G. xe2x80x9cHierarchical z-Buffer Visibility,xe2x80x9d SIGGRAPH ""93, pp.231-238] use a variety of hierarchical data structures to help exploit the spatial structure inherent in object space (an octree of objects), the image structure inherent in pixels (a Z pyramid), and the temporal structure inherent in frame-by-frame rendering (a list of previously visible octree nodes). The Z-pyramid permits the rapid culling of large portions of the model by testing for visibility using a rapid scan conversion of the cubes in the octree.
The depth complexity of graphical environments continues to increase in response to consumer demand for realism and performance. Thus, the efficiency of an algorithm for visible object determination has a direct impact on the marketability of a visualization system. The computational bandwidth required by the visible object determination algorithm determines the class of processor required for the visualization system, and thereby effects overall system cost. Thus, a system or method for improving the efficiency of visible object determination is greatly desired.
The present invention comprises a system and method for displaying visible objects in a graphics environment. In particular, a system and method for performing visible object determination based upon a dual search of a cone hierarchy and a bounding hierarchy is herein disclosed. The system includes a processor, a display device, system memory, and optionally a graphics accelerator. The processor executes visualization software which provides for visualization of a collection of three-dimensional objects on the display device. The objects reside in a three-dimensional space and thus admit the possibility of occluding one another.
The visualization software represents space in terms of a hierarchy of cones emanating from the viewpoint. In one embodiment, the leaf-cones of the hierarchy, i.e. the cones at the highest level of refinement, subtend an area which corresponds to a fraction of a pixel in screen area. For example, two cones may conveniently fill the area of a pixel. Alternatively, the leaf-cone may subtend areas which include one or more pixels.
An initial view frustum or neighborhood of the view frustum is recursively tessellated (i.e. refined) to generate a cone hierarchy. Alternatively, the entire space around the viewpoint may be recursively tessellated to generate the cone hierarchy. In this case, the cone hierarchy does not need to be recomputed for changes in the viewpoint and view-direction.
The visualization software also generates a hierarchy of bounds from the collection of objects. In particular, the bounding hierarchy is generated by: (a) recursively grouping clusters starting with the objects themselves as order-zero clusters, (b) bounding each object and cluster (of all orders) with a corresponding bound, e.g. a polytope hull, (c) allocating a node in the bounding hierarchy for each object and cluster, and (d) organizing the nodes in the bounding hierarchy to reflect cluster membership. For example if node A is the parent of node B, the cluster corresponding to node A contains a subcluster (or object) corresponding to node B. Each node stores parameters which characterize the bound of the corresponding cluster or object.
The visualization software performs a search of the cone and bounding hierarchies starting with the root cone and the root bound. Each leaf-cone is assigned a visibility distance value which represents the distance to the closest known object as perceived from within the leaf-cone. Each leaf-cone is also assigned an object attribute which specifies the closest known object within view of the leaf-cone. Similarly, each non-leaf cone is assigned a visibility distance value. However, the visibility distance value of a non-leaf cone is set equal to the maximum of the visibility distance values for its subcone children. This implies that the visibility distance value for each non-leaf cone equals the maximum of the visibility distance values of its leaf-cone descendents.
The visibility software operates on cone-bound pairs. Before exploring a given cone-bound pair, the distance between the cone and the bound is measured. This involves determining the minimum distance to points residing in both the bound and the cone from the vertex of the cone. This cone-bound distance is then compared to the visibility distance value of the cone. If the cone-bound distance is larger than the visibility distance value of the cone, all of the leaf-cone descendents of the given cone have known visible objects closer than the given bound by definition of the visibility distance value. Thus, no benefit can be gained from exploring the cone-bound pair. In contrast, if the cone-bound distance is smaller than the visibility distance value of the cone, the bound may contain objects which will affect the visibility distance values of one or more leaf-cone descendents of the given cone. The cone-bound pair must be searched. According to the present invention, cone-bound pairs are advantageously searched only when there is a possibility that the given bound may affect the visibility of the cone""s descendents. Thus, the search algorithm of the present invention avoids unnecessary cone-bound explorations and thereby saves considerable computational bandwidth.
Supposing that the search condition is satisfied, the bound is explored with respect to the given cone. If the cone and bound are both leaves of their respective hierarchies, the bound specifies an object which is closer than the closest known object for the leaf-cone. Thus, the visibility distance value of the leaf-cone is updated with the cone-bound distance between the cone and bound. Also, the object attribute for the cone is updated to point to the given bound.
In the case that the cone is a leaf-cone and the bound is a non-leaf bound, the search algorithm examines subbounds of the given bound, and conditionally explores these subbounds in ascending order of their cone-bound distance from the given cone. Again, exploration of a subbound is conditioned upon the subbound achieving a cone-bound distance to the given cone which is smaller than the cone""s visibility distance value.
In the case that the cone is a non-leaf cone and the bound is a leaf bound (i.e. one which bounds a single object), the search algorithm conditionally explores subcones of the given cone with respect to the given bound. Exploration of a subcone is conditioned upon the subcone achieving a cone-bound distance to the given bound which is smaller than the subcone""s visibility distance value.
In the case that the cone is a non-leaf cone and the bound is a non-leaf bound, the search algorithm conditionally explores subbounds of the given bound against the subcones of the given cone. Consider a particular subcone of the given cone for the sake of discussion. The subbounds of the given bound are conditionally explored against the subcone in ascending order of their cone-bound distances from the subcone. Because the closest subbound is searched first, and potentially decreases the visibility distance value of the given subcone, succeeding (more distant) subbounds will have more difficulty passing the search condition, i.e. of having a cone-bound distance to the given subcone which is less than the visibility distance value of the subcone. Thus, the probability is maximized that the fewest number of subbounds will need to be explored by ordering the conditional explorations according to cone-bound distance.
When the search of the two trees is completed, the object attribute of each leaf-cone points to the object which is visible to the leaf-cone, and the visibility distance value of the leaf-cone specifies the distance to the visible object. This visibility information is provided to the graphics accelerator so that the graphics accelerator may render the visible objects (or visible portions of visible object) on the display device.
In one embodiment, the visualization software provides for interactive visualization by reading user inputs to control the current viewpoint and view-direction in the graphics environment. Additional software ensures efficient computation through the use of careful state management and parallelism.
In one alternative embodiment, the cone hierarchy and bounding hierarchy are searched iteratively. In a second alternative embodiment, a level order search is performed on the cone hierarchy and the bounding hierarchy.
The present invention contemplates a wide variety of techniques for measuring the extent of separation or proximity between a bound and a cone. One set of embodiments focus of minimizing an increasing function of separation distance between the vertex of the cone and points in the intersection of the cone and the bound. Another set of embodiments involve maximizing a decreasing function of separation distance between the vertex of the cone and points in the intersection of the cone and the bound. In general, any wavefront with a boundary that obeys a mild xe2x80x9cstar shapexe2x80x9d condition may provide the basis for a measurement of separation between a bound and a cone.